from BST import BiTreeNode,BST

class AVLNode(BiTreeNode):
    def __init__(self, data) -> None:
        BiTreeNode.__init__(data)
        self.bf = 0

class AVLTree(BST):
    def __init__(self, li = None) -> None:
        BST.__init__(self,li)



    def rotate_left(self,p,c):# 左旋 右孩子的右子树插入导致的
        s2 = c.lchild
        p.rchild = s2
        if s2:
            s2.parent = p
        c.lchild = p
        p.parent = c

        p.bf = 0
        c.bf = 0
    
    def rotate_right(self,p,c):# 右旋 左孩子的左子树插入导致的
        s2 =   c.rchild
        p.lchild = s2
        if s2:
            s2.parent = p
        c.rchild = p
        p.parent = c
        
        p.bf = 0
        c.bf = 0

    def rotate_right_left(self,p,c):# 右旋 左旋 右孩子的左孩子插入导致的
        g = c.lchild
        s2 = g.lchild
        s3 = g.rchild
        if s3:
            s3.parent = c
        g.rchild = c
        c.parent = g
        if s2:
            s2.parent = p
        g.lchild = p
        p.parent = g

        
        #更新bf
        if g.bf > 0:
            p.bf = -1
            c.bf = 0
        elif g.bf < 0:
            p.bf = 0
            c.bf = 1
        else:
            p.bf = 0
            c.bf = 0
    
    def rotate_left_right(self,p,c):
        g = c.rchild

        s2 = g.lchild
        c.rchild = s2
        if s2:
            s2.parent = c
        g.lchild = c
        c.parent = g
        s3 = g.rchild
        p.lchild = s3
        if s3:
            s3.parent = p
        g.rchild = p
        p.parent = g

        # 更新bf
        if g.bf < 0:
            p.bf = 1
            c.bf = 0
        elif g.bf > 0:
            p.bf = 0
            c.bf = -1
        else:
            p.bf = 0
            c.bf = 0

    def insert_no_rec(self, val):
        p = self.root
        if not p:
            self.root = AVLNode(val)
            return

        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:
                    p.lchild = AVLNode(val)
                    p.lchild.parent = p
                    node  = p.lchild
                    break
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = AVLNode(val)
                    p.rchild.parent = p
                    node = p.rchild
                    break
            else: # val == p.data
                return
        
        while node.parent: #node.parent不空
            if node.parent.lchild == node:#传递时从左子树来了，左子树更沉了
                # 更新node.parent的bf -= 1
                g = node.parent.parent # 为了连接旋转之后的子树
                if node.parent.bf < 0: #原来node.parent.bf == -1，更新后变成-2
                    # 看node哪边沉:
                    if node.bf > 0:
                        n = self.rotate_left_right(node.parent,node)
                    else:
                        n = self.rotate_right(node.parent, node)
                elif node.parent.bf > 0: # 原来node.parent.bf = 1，更新之后变成0
                    node.parent.bf = 0
                    break
                else: # 原来node.parent.bf = 0 更新只有变成-1
                    node.parent.bf = -1
                    node = node.parent
                    continue    

            else: #传递是从右子树传来的
                if node.parent.bf > 0:
                    if node.bf < 0:
                        n = self.rotate_right_left(node.parent,node)
                    else:
                        n = self.rotate_left(node.parent,node)
                elif node.parent.bf < 0:
                    node.parent.bf = 0
                    break
                else:
                    node.parent.bf = 1
                    node = node.parent
                    continue

                #旋转后的子树
                n.parent = g
                if g:#g不是空
                    if node.parent == g.lchild:
                        g.lchild = n
                    else:
                        g.rchild = n
                    break
                else:
                    self.root = n
                    break













